home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / machack / Hacks97 / BugsinMySerial.sit / Bugs in My Serial / Bugs in My Serial code / SerialMainBrian.cpp < prev    next >
C/C++ Source or Header  |  1997-06-27  |  9KB  |  451 lines
  1. #include "patches.h"
  2. #include <traps.h>
  3. #include <lowmem.h>
  4. #include "MacsBugSerialStuff.h"
  5. #include <Gestalt.h>
  6. //#include "NNumToString.h"
  7. #include "ScreenMatrix.h"
  8.  
  9. static ScreenMatrix        gScreen;
  10.  
  11. static asm long*    GetOldDebugUtilStorage()
  12. {
  13.     lea        _oldDebugUtilStorage,a0
  14.     rts
  15. _oldDebugUtilStorage:
  16.     dc.l    0x00000000
  17. }
  18.  
  19. static asm long* GetCountStorage()
  20. {
  21.     lea        _countStorage,a0
  22.     rts
  23. _countStorage:
  24.     dc.l    0x00000000
  25. }
  26.  
  27.  
  28. static asm long* GetValueStorage()
  29. {
  30.     lea        _valueStorage,a0
  31.     rts
  32. _valueStorage:
  33.     dc.l    0x00000000
  34. }
  35.  
  36.  
  37. static asm long* GetA5Storage()
  38. {
  39.     lea        _a5Store,a0
  40.     rts
  41. _a5Store:
  42.     dc.l    0x00000000
  43. }
  44.  
  45. static Boolean        KeyIsDown(
  46.     short            theKeyCode)
  47. {
  48.     KeyMap            theKeys;
  49.     
  50.     GetKeys( theKeys);                    /* Get state of each key            */
  51.                                         
  52.         /* Ordering of bits in a KeyMap is truly bizarre. A KeyMap is a    */
  53.         /* 16-byte (128 bits) array where each bit specifies the start    */
  54.         /* of a key (0 = up, 1 = down). We isolate the bit for the        */
  55.         /* specified key code by first determining the byte position in    */
  56.         /* the KeyMap and then the bit position within that byte.        */
  57.         /* Key codes 0-7 are in the first byte (offset 0 from the        */
  58.         /* start), codes 8-15 are in the second, etc. The BitTst() trap    */
  59.         /* counts bits starting from the high-order bit of the byte.    */
  60.         /* For example, for key code 58 (the option key), we look at    */
  61.         /* the 8th byte (7 offset from the first byte) and the 5th bit    */
  62.         /* within that byte.                                            */
  63.         
  64.     return( BitTst( ((char*) &theKeys) + theKeyCode / 8,
  65.                     (long) 7 - (theKeyCode % 8) ) );
  66. }
  67.  
  68.  
  69. static    Ptr GetScreenBase()
  70. {
  71.     GDHandle        h = LMGetMainDevice();
  72.     
  73.     return h[0]->gdPMap[0]->baseAddr;
  74. }
  75.  
  76. static const SInt32 kCharBlitOffset            = 0x07B2;
  77.  
  78. typedef pascal void (*BlitCharProcPtr)(UInt8 character, PointPtr location);
  79.  
  80. BlitCharProcPtr        gBlitCharProc = NULL;
  81.  
  82.  
  83. const short    kCharWidth = 6;
  84. const short kCharHeight = 10;
  85.  
  86.  
  87. void SMoveTo(short tY,short tX);
  88. void SMoveTo(short tY,short tX)
  89. {
  90.     Str255        message;
  91.     Str31        s;
  92.     
  93.     message[0] = 1;
  94.     message[1] = 0x1B;
  95.     PLstrcat(message,"\p[");
  96.     NumToString(tY,s);
  97.     PLstrcat(message,s);
  98.     
  99.     message[++message[0]] = ';';
  100.     
  101.     NumToString(tX,s);
  102.     PLstrcat(message,s);
  103.     message[++message[0]] = ';';
  104.     message[++message[0]] = 'H';
  105.     
  106.     SerialDriver_SendBytes(message+1,message[0]);
  107.  
  108.  
  109. }
  110.  
  111. static void DrawCharAt(char inChar,short tX,short tY)
  112. {
  113.     
  114.     gScreen.DrawChar(tY,tX,inChar);
  115.     SMoveTo(tY,tX);
  116.     SerialDriver_SendBytes((unsigned char*)&inChar,1);
  117. }
  118.  
  119.  
  120. static void    SendByte(UInt8 inByte,Point inPoint)
  121. {
  122.     if(inPoint.v > 240) inPoint.v += 10;    
  123.     if(inPoint.v > 400) inPoint.v += 10;    
  124.     short        tX = (inPoint.h/kCharWidth)+1;
  125.     short        tY = (inPoint.v/kCharHeight)+1;
  126.  
  127.     DrawCharAt(inByte,tX,tY);
  128. }
  129.  
  130. const    short    kVerticalYStart = 1;
  131. const    short    kVerticalYEnd = 49;
  132. const    short    kVerticalXStart = 12;
  133.  
  134. const    short    kHorzXStart = 0;
  135.  
  136. static void    DrawVerticalFrame(short x,short y)
  137. {
  138.     DrawCharAt('|',x,y);
  139.  
  140. }
  141.  
  142. static void    DrawHorzFrame(short x,short y);
  143.  
  144. static void    DrawFrames()
  145. {
  146.  
  147.     for(short y = kVerticalYStart;y<= kVerticalYEnd;y++){
  148.         DrawVerticalFrame(kVerticalXStart,y);
  149.     }
  150. /*    
  151.     for(short x = kHorzXStart;x<=kHorzXEnd;x++){
  152.         DrawHorzFrame(x,kHorzYStart);
  153.     }
  154. */
  155. }
  156.  
  157.  
  158. static void    SendClear()
  159. {
  160.     Str32        s;
  161.     
  162.     s[0] = 1; s[1] = 0x1B;
  163.     PLstrcat(s,"\p[2J");
  164.     SerialDriver_SendBytes(s+1,s[0]);
  165.  
  166.  
  167. }
  168.  
  169. static Boolean    ControlKeyQ()
  170. {
  171.     KeyMap        keys;
  172.     
  173.     GetKeys(keys);
  174.     
  175.     return ((keys[1] & 0x00000008) != 0);
  176. }
  177.  
  178. static void RefreshScreen()
  179. {
  180.     SendClear();
  181.     for(long    row = 1;row<=ScreenMatrix::kHeight;row++){
  182.         Ptr        theRow;
  183.         long    theSize;
  184.         
  185.         theRow = gScreen.GetIndRow(row,theSize);
  186.         
  187.         SMoveTo(row,1);
  188.         SerialDriver_SendBytes((unsigned char*)theRow,theSize);
  189.     }
  190. }
  191.  
  192. static void ReceiveData(long inMBA5)
  193. {
  194.     gScreen.Sync();
  195.     if(SerialDriver_BytePresent()){
  196.         UInt8    theByte;
  197.         
  198.     //    Ptr        p = GetScreenBase();
  199.     //    *p = (*p)?0:0xFF;
  200.  
  201.         if(SerialDriver_ReceiveByte(&theByte,10) == noErr){
  202.             if(theByte == '`'){
  203.                 RefreshScreen();
  204.             }else{
  205.                 long    myA5 = SetA5(inMBA5);
  206.                 PostEvent(keyDown,theByte);
  207.                 PostEvent(keyUp,0);
  208.                 SetA5(myA5);
  209.             }
  210.         }
  211.     }
  212.     
  213.     
  214. }
  215.  
  216.  
  217.  
  218.  
  219. /*
  220. static BlitCharProcPtr FinalBlitChar(UInt8 character, PointPtr location)
  221. {
  222.     #pragma unused(character, location)
  223.     long*                theA5 = GetA5Storage();
  224.     SInt32                oldA5;
  225.     BlitCharProcPtr        proc;
  226.     
  227.     oldA5 = SetA5(*theA5);
  228.     proc = gBlitCharProc;
  229.     SetA5(oldA5);
  230.     
  231.     return proc;
  232. }
  233.  
  234. static asm pascal void BlitChar(UInt8 character, PointPtr location)
  235. {
  236.     subq.l                #4, sp
  237.     movem.l                a0-a5/d0-d7, -(sp)
  238.     move.l                56+8(sp), -(sp)
  239.     move.w                56+16(sp), -(sp)
  240.     jsr                    FinalBlitChar
  241.     addq.l                #6, sp
  242.     move.l                a0, d0
  243.     beq                    NoCall
  244.     move.l                a0, 56(sp)
  245.     movem.l                (sp)+, a0-a5/d0-d7
  246.     rts
  247. NoCall:
  248.     movem.l                (sp)+, a0-a5/d0-d7
  249.     addq.l                #4, sp
  250.     move.l                (sp)+, a0
  251.     addq.l                #6, sp
  252.     jmp                    (a0)
  253. }
  254.  
  255. */
  256.  
  257. struct RedirectCode
  258. {
  259.     UInt16                jmp;    // 0x4EF9
  260.     UInt32                addr;
  261.     UInt16                nop;    // 0x4E71
  262. } ;
  263.  
  264. struct DisplacedCode
  265. {
  266.     UInt16                setA1;    // 0x225F
  267.     UInt16                setA0;    // 0x205F
  268.     UInt16                clrD1;    // 0x4241
  269.     UInt16                setD1;    // 0x121F
  270.     UInt16                jmp;    // 0x4EF9
  271.     UInt32                addr;
  272. } ;
  273.  
  274. static void _SetUpDisplacedAddr(UInt32* addrPtr)
  275. {
  276.     long*                theA5 = GetA5Storage();
  277.     SInt32                oldA5;
  278.     
  279.     oldA5 = SetA5(*theA5);
  280.     *addrPtr = reinterpret_cast<UInt32>(gBlitCharProc);
  281.     (*addrPtr) += 8;
  282.     SetA5(oldA5);
  283. }
  284.  
  285. static void SendCharToBlit(UInt8* character, PointPtr location)
  286. {
  287.     #pragma unused(character, location)
  288.     long*                theA5 = GetA5Storage();
  289.     SInt32                oldA5;
  290.     
  291.     oldA5 = SetA5(*theA5);
  292.     
  293.     SendByte(*character,*location);
  294.     
  295.     
  296. //    if (*character == '0')
  297. //        *character = '.';
  298.     SetA5(oldA5);
  299. }
  300.  
  301. static void SetUpDisplacedAddr(void);
  302.  
  303. static asm pascal void BlitChar(UInt8 character, PointPtr location)
  304. {
  305.     movem.l                a0-a5/d0-d7, -(sp)
  306.     move.l                52+8(sp), -(sp)
  307.     // move.w                56+16(sp), -(sp)
  308.     pea                    52+16(sp)
  309.     jsr                    SendCharToBlit
  310.     addq.l                #8, sp
  311.     movem.l                (sp)+, a0-a5/d0-d7
  312.     // begin displaced code
  313.     move.l                (sp)+, a1
  314.     move.l                (sp)+, a0
  315.     clr.w                d1
  316.     move.b                (a7)+, d1
  317.     // end displaced code
  318.         dc.w    0x4EF9
  319. _addr:    dc.l    0
  320.     
  321.     entry        static SetUpDisplacedAddr
  322.     pea            _addr
  323.     jsr            _SetUpDisplacedAddr
  324.     addq.l        #4,sp
  325.     rts
  326. }
  327.  
  328. static long    Poll(short selector)
  329. {
  330.     long                continueQ = true;
  331.     long*                theA5 = GetA5Storage();
  332.     SInt32                oldA5;
  333.     BlitCharProcPtr*    proc;
  334.     
  335.     oldA5 = SetA5(*theA5);
  336.     
  337.     /*Point            pt = { -1, -1 };
  338.     UInt8            tChar = 'Z';
  339.     
  340.     SendCharToBlit(tChar, &pt);*/
  341.     
  342.     switch(selector)
  343.     {
  344.         case 1:
  345.             SendClear();
  346.             DrawFrames();
  347.             proc = reinterpret_cast<BlitCharProcPtr*>(oldA5 - kCharBlitOffset);
  348.             gBlitCharProc = *proc;
  349.             
  350.             SetUpDisplacedAddr();
  351.             
  352.             RedirectCode*    redir;
  353.             
  354.             redir = reinterpret_cast<RedirectCode*>(*proc);
  355.             redir->jmp = 0x4EF9;
  356.             redir->addr = reinterpret_cast<UInt32>(BlitChar);
  357.             redir->nop = 0x4E71;
  358.  
  359. #if GENERATING68K
  360.             FlushCodeCacheRange(redir, sizeof(RedirectCode));
  361. #else
  362.             MakeDataExecutable(redir, sizeof(RedirectCode));
  363. #endif
  364.             
  365.             /*
  366.             *proc = BlitChar;
  367.             */
  368.             // Gestalt('S2S ', (long*)&proc);
  369.             // *proc = gBlitCharProc;
  370.             break;
  371.         case 2:
  372.             proc = reinterpret_cast<BlitCharProcPtr*>(oldA5 - kCharBlitOffset);
  373.             
  374.             DisplacedCode*    disp;
  375.             
  376.             disp = reinterpret_cast<DisplacedCode*>(*proc);
  377.             disp->setA1 = 0x225F;
  378.             disp->setA0 = 0x205F;
  379.             disp->clrD1 = 0x4241;
  380.             disp->setD1 = 0x121F;
  381.  
  382. #if GENERATING68K
  383.             FlushCodeCacheRange(disp, sizeof(RedirectCode));    // sizeof(RedirectCode) is NOT a mistake
  384. #else
  385.             MakeDataExecutable(disp, sizeof(RedirectCode));    // sizeof(RedirectCode) is NOT a mistake
  386. #endif
  387.             
  388.             /*
  389.             *proc = gBlitCharProc;
  390.             */
  391.             gBlitCharProc = NULL;
  392.             break;
  393.         case 3:
  394.             ReceiveData(oldA5);
  395.             break;
  396.     }
  397.     
  398.     SetA5(oldA5);
  399.         
  400.     return continueQ;
  401. }
  402.  
  403.  
  404. static asm void newDebugUtil()
  405. {
  406.     subq.l    #4,a7                        // reserve space for old trap address
  407.     move.l    a0,-(a7)                    // save a0
  408.     movem.l    a1-a5/d0-d7,-(a7)            // save everything else
  409.     
  410.     move.w    d0,-(a7)
  411.     jsr        Poll
  412.     addq.l    #2,a7
  413.     tst.w    d0
  414.     bne.s    _Continue
  415.     
  416.     movem.l    (a7)+,a1-a5/d0-d7
  417.     move.l    (a7)+,a0
  418.     addq.l    #4,a7
  419.     rts
  420.     
  421. _Continue:
  422.     
  423.  
  424.     movem.l    (a7)+,a1-a5/d0-d7            // restore registers
  425.     
  426.     jsr        GetOldDebugUtilStorage        // get original trap address storage in a0
  427.     move.l    (a0),a0                        // get original trap address value into a0
  428.     move.l    a0,4(a7)                    // stuff old trap onto stack
  429.     move.l    (a7)+,a0                    // restore original a0
  430.     rts                                    // rts to jump to old trap.
  431. }
  432.  
  433. void main()
  434. {
  435.     
  436.     SerialDriver_Open();
  437.     
  438.     
  439.  
  440.     long*        theA5 = GetA5Storage();
  441.     *theA5 = SetCurrentA5();
  442.  
  443.     long*        debugUtilStorage = GetOldDebugUtilStorage();
  444.     *debugUtilStorage = PatchTrap(_DebugUtil,(long)newDebugUtil);
  445.     
  446.     (*((ProcPtr)0xFFFFFFFF))();
  447.     
  448. //    SysBeep(1);
  449. //    SysBeep(1);
  450.  
  451. }